{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
    "\n",
    "```shell\n",
    "pip install tensorflow-cpu\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:08.125203900Z",
     "start_time": "2024-04-29T02:49:56.553689Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:45:59.270516Z",
     "iopub.status.busy": "2025-01-21T06:45:59.270253Z",
     "iopub.status.idle": "2025-01-21T06:46:01.389869Z",
     "shell.execute_reply": "2025-01-21T06:46:01.389332Z",
     "shell.execute_reply.started": "2025-01-21T06:45:59.270496Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备\n",
    "\n",
    "https://www.kaggle.com/competitions/cifar-10/data\n",
    "\n",
    "```shell\n",
    "$ tree -L 1 cifar-10                                    \n",
    "cifar-10\n",
    "├── sampleSubmission.csv\n",
    "├── test\n",
    "├── train\n",
    "└── trainLabels.csv\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:01.391389Z",
     "iopub.status.busy": "2025-01-21T06:46:01.390831Z",
     "iopub.status.idle": "2025-01-21T06:46:01.393562Z",
     "shell.execute_reply": "2025-01-21T06:46:01.393101Z",
     "shell.execute_reply.started": "2025-01-21T06:46:01.391365Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# %pip install py7zr\n",
    "# import py7zr\n",
    "# a = py7zr.SevenZipFile(r'../input/cifar-10/train.7z','r')\n",
    "# a.extractall(path=r'./')\n",
    "# a.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:01.394307Z",
     "iopub.status.busy": "2025-01-21T06:46:01.394134Z",
     "iopub.status.idle": "2025-01-21T06:46:01.511635Z",
     "shell.execute_reply": "2025-01-21T06:46:01.511010Z",
     "shell.execute_reply.started": "2025-01-21T06:46:01.394289Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "04_10_monkeys_model_1_aliyun.ipynb\t\t       runs\n",
      "05_10_monkeys_model_2_resnet50_finetune_2aliyun.ipynb  sampleSubmission.csv\n",
      "06_cifar10_model_2.ipynb\t\t\t       submission.csv\n",
      "checkpoints\t\t\t\t\t       test.7z\n",
      "competitions\t\t\t\t\t       train.7z\n",
      "kaggle.json\t\t\t\t\t       trainLabels.csv\n",
      "new-vgg-aliyun.ipynb\n"
     ]
    }
   ],
   "source": [
    "#我们不运行test数据集，太多图片\n",
    "!ls ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:01.513073Z",
     "iopub.status.busy": "2025-01-21T06:46:01.512470Z",
     "iopub.status.idle": "2025-01-21T06:46:01.627751Z",
     "shell.execute_reply": "2025-01-21T06:46:01.627129Z",
     "shell.execute_reply.started": "2025-01-21T06:46:01.513038Z"
    }
   },
   "outputs": [],
   "source": [
    "!mkdir test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:17.556866200Z",
     "start_time": "2024-04-29T02:50:13.332056200Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:01.630423Z",
     "iopub.status.busy": "2025-01-21T06:46:01.629953Z",
     "iopub.status.idle": "2025-01-21T06:46:03.912703Z",
     "shell.execute_reply": "2025-01-21T06:46:03.912046Z",
     "shell.execute_reply.started": "2025-01-21T06:46:01.630390Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(PosixPath('competitions/cifar-10/train/1.png'), 'frog'),\n",
      " (PosixPath('competitions/cifar-10/train/2.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/3.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/4.png'), 'deer'),\n",
      " (PosixPath('competitions/cifar-10/train/5.png'), 'automobile')]\n",
      "[(PosixPath('competitions/cifar-10/test/1.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/2.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/3.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/4.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/5.png'), 'cat')]\n",
      "50000 300000\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "DATA_DIR = Path(\".\")\n",
    "DATA_DIR1 =Path(\"competitions/cifar-10/\")\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\" #测试集模板csv文件\n",
    "train_folder = DATA_DIR1 / \"train\"\n",
    "test_folder = DATA_DIR1 / \"test\"\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "def parse_csv_file(filepath, folder):\n",
    "    \"\"\"Parses csv files into (filename(path), label) format\"\"\"\n",
    "    results = []\n",
    "    #读取所有行\n",
    "    with open(filepath, 'r') as f:\n",
    "#         lines = f.readlines()  为什么加[1:]，可以试这个\n",
    "        #第一行不需要，因为第一行是标签\n",
    "        lines = f.readlines()[1:] \n",
    "    for line in lines:#依次去取每一行\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "        results.append((image_full_path, label_str)) #得到对应图片的路径和分类\n",
    "    return results\n",
    "\n",
    "#解析对应的文件夹\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)\n",
    "#打印\n",
    "import pprint\n",
    "pprint.pprint(train_labels_info[0:5])\n",
    "pprint.pprint(test_csv_info[0:5])\n",
    "print(len(train_labels_info), len(test_csv_info))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:22.471835700Z",
     "start_time": "2024-04-29T02:50:22.346907200Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:03.914011Z",
     "iopub.status.busy": "2025-01-21T06:46:03.913478Z",
     "iopub.status.idle": "2025-01-21T06:46:03.971502Z",
     "shell.execute_reply": "2025-01-21T06:46:03.970860Z",
     "shell.execute_reply.started": "2025-01-21T06:46:03.913976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            filepath       class\n",
      "0  competitions/cifar-10/train/1.png        frog\n",
      "1  competitions/cifar-10/train/2.png       truck\n",
      "2  competitions/cifar-10/train/3.png       truck\n",
      "3  competitions/cifar-10/train/4.png        deer\n",
      "4  competitions/cifar-10/train/5.png  automobile\n",
      "                                filepath       class\n",
      "0  competitions/cifar-10/train/45001.png       horse\n",
      "1  competitions/cifar-10/train/45002.png  automobile\n",
      "2  competitions/cifar-10/train/45003.png        deer\n",
      "3  competitions/cifar-10/train/45004.png  automobile\n",
      "4  competitions/cifar-10/train/45005.png    airplane\n",
      "                           filepath class\n",
      "0  competitions/cifar-10/test/1.png   cat\n",
      "1  competitions/cifar-10/test/2.png   cat\n",
      "2  competitions/cifar-10/test/3.png   cat\n",
      "3  competitions/cifar-10/test/4.png   cat\n",
      "4  competitions/cifar-10/test/5.png   cat\n"
     ]
    }
   ],
   "source": [
    "# train_df = pd.DataFrame(train_labels_info)\n",
    "train_df = pd.DataFrame(train_labels_info[0:45000])\n",
    "valid_df = pd.DataFrame(train_labels_info[45000:])\n",
    "test_df = pd.DataFrame(test_csv_info)\n",
    "\n",
    "train_df.columns = ['filepath', 'class']\n",
    "valid_df.columns = ['filepath', 'class']\n",
    "test_df.columns = ['filepath', 'class']\n",
    "\n",
    "print(train_df.head())\n",
    "print(valid_df.head())\n",
    "print(test_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:31.586523100Z",
     "start_time": "2024-04-29T02:50:28.504142500Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:03.972824Z",
     "iopub.status.busy": "2025-01-21T06:46:03.972308Z",
     "iopub.status.idle": "2025-01-21T06:46:04.781633Z",
     "shell.execute_reply": "2025-01-21T06:46:04.781099Z",
     "shell.execute_reply.started": "2025-01-21T06:46:03.972790Z"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "class Cifar10Dataset(Dataset):\n",
    "    df_map = {\n",
    "        \"train\": train_df,\n",
    "        \"eval\": valid_df,\n",
    "        \"test\": test_df\n",
    "    }\n",
    "    label_to_idx = {label: idx for idx, label in enumerate(class_names)}\n",
    "    idx_to_label = {idx: label for idx, label in enumerate(class_names)}\n",
    "    def __init__(self, mode, transform=None):\n",
    "        self.df = self.df_map.get(mode, None)\n",
    "        if self.df is None:\n",
    "            raise ValueError(\"mode should be one of train, val, test, but got {}\".format(mode))\n",
    "\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        img_path, label = self.df.iloc[index]\n",
    "        img = Image.open(img_path).convert('RGB')\n",
    "        # # img 转换为 channel first\n",
    "        # img = img.transpose((2, 0, 1))\n",
    "        # transform\n",
    "        img = self.transform(img)\n",
    "        # label 转换为 idx\n",
    "        label = self.label_to_idx[label]\n",
    "        return img, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.df.shape[0]\n",
    "    \n",
    "IMAGE_SIZE = 32\n",
    "mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n",
    "\n",
    "transforms_train = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        # random rotation 40\n",
    "        transforms.RandomRotation(40),\n",
    "        # horizaontal flip\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "transforms_eval = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "train_ds = Cifar10Dataset(\"train\", transforms_train)\n",
    "eval_ds = Cifar10Dataset(\"eval\", transforms_eval) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:51:31.864180800Z",
     "start_time": "2024-04-29T02:51:31.841167400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.782891Z",
     "iopub.status.busy": "2025-01-21T06:46:04.782344Z",
     "iopub.status.idle": "2025-01-21T06:46:04.785961Z",
     "shell.execute_reply": "2025-01-21T06:46:04.785438Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.782864Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=4)   \n",
    "eval_dl = DataLoader(eval_ds, batch_size=batch_size, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:19.396136500Z",
     "start_time": "2023-12-05T09:46:43.935044500Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.786836Z",
     "iopub.status.busy": "2025-01-21T06:46:04.786615Z",
     "iopub.status.idle": "2025-01-21T06:46:04.789337Z",
     "shell.execute_reply": "2025-01-21T06:46:04.788884Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.786817Z"
    }
   },
   "outputs": [],
   "source": [
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "#这里不需要每次都执行，只需要执行一次就可以了，所以注释掉\n",
    "# def cal_mean_std(ds):\n",
    "#     mean = 0.\n",
    "#     std = 0.\n",
    "#     for img, _ in ds:\n",
    "#         mean += img.mean(dim=(1, 2))\n",
    "#         std += img.std(dim=(1, 2))\n",
    "#     mean /= len(ds)\n",
    "#     std /= len(ds)\n",
    "#     return mean, std\n",
    "#\n",
    "# # 经过 normalize 后 均值为0，方差为1\n",
    "# print(cal_mean_std(train_ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:52:55.126913100Z",
     "start_time": "2024-04-29T02:52:55.080936200Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.790020Z",
     "iopub.status.busy": "2025-01-21T06:46:04.789854Z",
     "iopub.status.idle": "2025-01-21T06:46:04.800044Z",
     "shell.execute_reply": "2025-01-21T06:46:04.799590Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.790003Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 9216\n",
      "              model.5.bias              paramerters num: 32\n",
      "             model.7.weight             paramerters num: 9216\n",
      "              model.7.bias              paramerters num: 32\n",
      "            model.10.weight             paramerters num: 9216\n",
      "             model.10.bias              paramerters num: 32\n",
      "            model.12.weight             paramerters num: 9216\n",
      "             model.12.bias              paramerters num: 32\n",
      "            model.16.weight             paramerters num: 5120\n",
      "             model.16.bias              paramerters num: 10\n"
     ]
    }
   ],
   "source": [
    "class VGG(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=\"same\"),# 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2), # 32*4*4\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(512, num_classes),\n",
    "        )\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "        \n",
    "for key, value in VGG(len(class_names)).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-21T06:41:50.445101Z",
     "start_time": "2025-01-21T06:41:50.441569Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.800691Z",
     "iopub.status.busy": "2025-01-21T06:46:04.800510Z",
     "iopub.status.idle": "2025-01-21T06:46:04.804608Z",
     "shell.execute_reply": "2025-01-21T06:46:04.804173Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.800673Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*4*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T08:24:38.083191700Z",
     "start_time": "2024-07-23T08:24:38.072843500Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.805417Z",
     "iopub.status.busy": "2025-01-21T06:46:04.805130Z",
     "iopub.status.idle": "2025-01-21T06:46:04.808778Z",
     "shell.execute_reply": "2025-01-21T06:46:04.808205Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.805398Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:53:41.778122600Z",
     "start_time": "2024-04-29T02:53:41.736145400Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.809881Z",
     "iopub.status.busy": "2025-01-21T06:46:04.809482Z",
     "iopub.status.idle": "2025-01-21T06:46:04.816488Z",
     "shell.execute_reply": "2025-01-21T06:46:04.815987Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.809851Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trainable parameters: 52266\n"
     ]
    }
   ],
   "source": [
    "#模型总参数量\n",
    "total_params = sum(p.numel() for p in VGG(len(class_names)).parameters() if p.requires_grad)\n",
    "print(f\"Total trainable parameters: {total_params}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:19.650361500Z",
     "start_time": "2023-12-05T09:51:19.432189700Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.819460Z",
     "iopub.status.busy": "2025-01-21T06:46:04.819152Z",
     "iopub.status.idle": "2025-01-21T06:46:04.846561Z",
     "shell.execute_reply": "2025-01-21T06:46:04.846103Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.819440Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.334347900Z",
     "start_time": "2023-12-05T09:51:19.656342Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.847777Z",
     "iopub.status.busy": "2025-01-21T06:46:04.847313Z",
     "iopub.status.idle": "2025-01-21T06:46:04.907480Z",
     "shell.execute_reply": "2025-01-21T06:46:04.907013Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.847745Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.347424300Z",
     "start_time": "2023-12-05T09:51:26.337347300Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.908474Z",
     "iopub.status.busy": "2025-01-21T06:46:04.908064Z",
     "iopub.status.idle": "2025-01-21T06:46:04.913366Z",
     "shell.execute_reply": "2025-01-21T06:46:04.912894Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.908452Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.371402100Z",
     "start_time": "2023-12-05T09:51:26.351411800Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.914156Z",
     "iopub.status.busy": "2025-01-21T06:46:04.913956Z",
     "iopub.status.idle": "2025-01-21T06:46:04.918260Z",
     "shell.execute_reply": "2025-01-21T06:46:04.917785Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.914137Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2023-12-05T09:51:26.364406400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:04.919099Z",
     "iopub.status.busy": "2025-01-21T06:46:04.918892Z",
     "iopub.status.idle": "2025-01-21T06:47:21.374821Z",
     "shell.execute_reply": "2025-01-21T06:47:21.374251Z",
     "shell.execute_reply.started": "2025-01-21T06:46:04.919070Z"
    },
    "is_executing": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7040/7040 [01:16<00:00, 92.37it/s, epoch=9] \n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 10\n",
    "\n",
    "model = VGG(num_classes=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "#可以修改adam里边的weight_decay参数，来控制L2正则化的程度,beta1和beta2是指数衰减率\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/vgg\")\n",
    "tensorboard_callback.draw_model(model, [1, 3, IMAGE_SIZE, IMAGE_SIZE])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/vgg\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    eval_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:47:21.375822Z",
     "iopub.status.busy": "2025-01-21T06:47:21.375549Z",
     "iopub.status.idle": "2025-01-21T06:47:21.624424Z",
     "shell.execute_reply": "2025-01-21T06:47:21.623939Z",
     "shell.execute_reply.started": "2025-01-21T06:47:21.375799Z"
    },
    "is_executing": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=100)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:47:21.625322Z",
     "iopub.status.busy": "2025-01-21T06:47:21.625007Z",
     "iopub.status.idle": "2025-01-21T06:47:22.290255Z",
     "shell.execute_reply": "2025-01-21T06:47:22.289643Z",
     "shell.execute_reply.started": "2025-01-21T06:47:21.625301Z"
    },
    "is_executing": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1274/244139278.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"checkpoints/vgg/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.8730\n",
      "accuracy: 0.7008\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/vgg/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 推理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:47:22.291308Z",
     "iopub.status.busy": "2025-01-21T06:47:22.290944Z",
     "iopub.status.idle": "2025-01-21T06:47:22.293881Z",
     "shell.execute_reply": "2025-01-21T06:47:22.293440Z",
     "shell.execute_reply.started": "2025-01-21T06:47:22.291285Z"
    },
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "# # test_df\n",
    "# test_ds = Cifar10Dataset(\"test\", transform=transforms_eval)\n",
    "# test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, drop_last=False)\n",
    "#\n",
    "# preds_collect = []\n",
    "# model.eval()\n",
    "# for data, fake_label in tqdm(test_dl):\n",
    "#     data = data.to(device=device)\n",
    "#     logits = model(data)\n",
    "#     preds = [test_ds.idx_to_label[idx] for idx in logits.argmax(axis=-1).cpu().tolist()]\n",
    "#     preds_collect.extend(preds)\n",
    "#\n",
    "# test_df[\"class\"] = preds_collect\n",
    "# test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:47:22.294784Z",
     "iopub.status.busy": "2025-01-21T06:47:22.294481Z",
     "iopub.status.idle": "2025-01-21T06:47:22.296790Z",
     "shell.execute_reply": "2025-01-21T06:47:22.296361Z",
     "shell.execute_reply.started": "2025-01-21T06:47:22.294764Z"
    },
    "is_executing": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # 导出 submission.csv\n",
    "# test_df.to_csv(\"submission.csv\", index=False)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "databundleVersionId": 46718,
     "sourceId": 3649,
     "sourceType": "competition"
    }
   ],
   "dockerImageVersionId": 30588,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
